package com.usian.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.usian.articles.Articles;
import com.usian.mapper.UserMapper;
import com.usian.certified.Certified;
import com.usian.service.UserService;
import com.usian.user.User;
import com.usian.utils.AliyunOSSUtils;
import com.usian.vo.Result;
import jakarta.websocket.server.PathParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.TimeUnit;

@RequestMapping("/app/user")
@RestController
public class UserController {

    /**
     * 接口：手机号雁阵那
     */
    @Autowired
    private UserService userService;

    @Value("${aliyun.sms.templateCode}")
    private String templateCode;

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisTemplate redisTemplate;


    @PostMapping("logon")
    public Result logon(@RequestBody User user) {
        return userService.logon(user);
    }
    @GetMapping("/sendSMS")
    private Result sendSMS(@RequestParam("mobile") String phone) throws JsonProcessingException {

        Random random = new Random();
        StringBuilder numberDer = new StringBuilder();

        for (int i = 0; i < 6; i++) {
            numberDer.append(random.nextInt(10)); // 生成0到9之间的随机数字
        }

        String code = numberDer.toString();

        // 或者可以使用更安全的方式
        Map<String, String> params = new HashMap<>();
        params.put("code", code);
        ObjectMapper objectMapper = new ObjectMapper();
        String templateParam = objectMapper.writeValueAsString(params); // 使用Jackson库保证JSON格式

        // 调用aliyunSendSmsService发送短信
        Boolean bool = userService.sendMessage(phone, templateCode, templateParam);

        if (bool) {
            // 如果发送成功，则将生成的4位随机验证码存入redis缓存,1分钟后过期
            redisTemplate.opsForValue().set(phone, templateParam, 5, TimeUnit.MINUTES);
            return Result.success("验证码发送成功！请注意接收");
        } else {
            return Result.error(phone + " ： " + code + "发送失败！");
        }
    }

    @PostMapping("/smsLogin")
    public ResponseEntity<Result> login(@RequestBody User user) {
        return userService.login(user);
    }

    /**
     * 接口：上传文件到OSS里面
     */

    @Autowired
    private AliyunOSSUtils aliyunOSSUtils;

    @PostMapping("/upload")
    public Result upload(@RequestParam("Image") MultipartFile file) throws IOException {
        // 获取文件名
        String filename = file.getOriginalFilename();
        // 获取io流
        InputStream inputStream = file.getInputStream();
        // 文件上传
        String fileUtils = aliyunOSSUtils.putObject(inputStream, filename);
        return Result.success(fileUtils);
    }

    /**
     * 接口：修改用户信息
     *
     * @param user
     * @return
     */
    @RequestMapping("/userInfoEdit")
    public Result userInfoEdit(@RequestBody User user) {
        int i = userService.userInfoEdit(user);
        if (i > 0) {
            return Result.success();
        } else {
            return Result.error("修改失败");
        }
    }

    /**
     * 接口：根据Id查询用户信息
     * @param id
     * @return
     */
    @GetMapping("userInfo/{id}")
    public Result selectUserOne(@PathVariable Integer id) {
        User user = userService.selectUserOne(id);
        return Result.success(user);
    }

    /**
     * 接口：通过用户id查找到动态用户表里面的动态id进行查询
     */
    @GetMapping("/selectUserArticles/{id}")
    public Result selectUserArticles(@PathVariable Integer id) {
        List<Articles> articles = userService.selectUserArticles(id);
        return Result.success(articles);
    }

    /**
     * 接口：通过用户id，查询这个用户的关注列表
     */
    @GetMapping("/concernList/{id}")
    public Result concernList(@PathVariable("id") Integer id) {
        List<User> users = userService.concernList(id);
        return Result.success(users);
    }

    /**
     * 接口：通过用户id删除关注列表的关注
     */
    @GetMapping("/deleteConcern/{id}/{userid}")
    public Result deleteConcern(@PathVariable("id") Integer id,@PathVariable("userid") Integer userid) {
        return userService.deleteConcern(id,userid);
    }


    /**
     * 接口：根据前段传过来的uid进行查询
     */
    @PostMapping("/list")
    public Result userList(@RequestParam("id") Integer id) {
        List<Articles> articlesList = userService.selectUserArticles(id);
        return Result.success(articlesList);
    }

    /**
     * 接口：根据前段传过来的动态id删除对应的动态
     */
    @GetMapping("/deleteArticlesUser/{id}")
    public Result deleteArticlesUser(@PathVariable("id") Integer id) {
        int i = userService.deleteArticlesUser(id);
        if (i > 0) {
            return Result.success();
        } else {
            return Result.error("删除失败");
        }
    }

    /**
     * 接口：根据前段传过来的用户id来删除动态数量
     */
    @GetMapping("/deleteEssayUser/{uid}")
    public Result deleteEssayUser(@PathVariable("uid") Integer id) {
        userMapper.deleteArticlesUser(id);
        return Result.success();
    }
    /**
     * 接口：根据前段传过来的用户id来删除关注数量
     */
    @GetMapping("/deleteConcernUser/{uid}")
    public Result deleteConcernUser(@PathVariable("uid") Integer id) {
//        userMapper.deleteConcern(id);
        return Result.success();
    }

    /**
     * 处理用户关注操作的控制器方法
     * 使用GET请求来处理关注操作，通常表示查询或获取某种资源的关注状态或信息
     *
     * @param id 用户ID，表示当前操作用户
     * @param userid 关注的目标用户ID
     * @return 关注操作的结果，封装在Result对象中
     */
    @GetMapping("/concern/{id}/{userid}")
    public Result concern(@PathVariable("id") Integer id,@PathVariable("userid") Integer userid) {
        return userService.concern(id,userid);
    }

    @GetMapping("/close/{userid}/{id}")
    public Result close(@PathVariable("userid") Integer userid,@PathVariable("id") Integer id) {
        return userService.close(userid,id);
    }

    /**
     * 处理用户身份信息认证请求
     * 该方法首先检查用户提交的实名和身份证号是否已存在于系统中
     * 如果不存在，则保存用户的身份信息并返回成功消息
     * 如果存在，则返回错误消息，提示身份信息已被占用
     *
     * @param certified 包含用户身份信息的实体，包括真实姓名、身份证号和用户ID
     * @return 返回一个Result对象，包含处理结果和相应的消息
     */
    @PostMapping("/certified")
    public Result certified(@RequestBody Certified certified) {
        // 根据用户提交的真实姓名和身份证号查询系统中是否已存在相同的认证信息
        List<Certified> cards = userService.certified(certified.getIdCard());

        // 如果查询结果为空，说明身份信息未被占用，可以进行认证
        if (cards.size() == 0){
            // 保存用户的身份信息到数据库
            userService.savecertified(certified.getUserId(),certified.getRealName(),certified.getIdCard());
            // 返回认证成功的结果和消息
            return Result.success("恭喜您，您的身份信息已经认证成功");
        }else {
            // 如果查询结果不为空，说明身份信息已被占用，返回错误消息提示用户
            return Result.error("身份信息已被占用，请您确认您的身份是否填写正确");
        }
    }
    /**
     * 根据用户ID选择认证的文章
     * 此方法通过GET请求获取用户ID对应的认证文章信息，返回给前端
     * 使用GetMapping注解来映射HTTP GET请求到这个处理方法
     *
     * @param id 用户ID，用于查询认证文章
     * @return 包含认证文章信息的Result对象
     */
    @GetMapping("/selectCertifiedArticles/{id}")
    public Result selectCertifiedArticles(@PathVariable Integer id) {
        // 调用userService的selectCertifiedArticles方法，根据用户ID获取认证文章
        Certified articles = userService.selectCertifiedArticles(id);
        // 返回成功结果，包含获取到的认证文章信息
        return Result.success(articles);
    }
    @GetMapping("/essay/{id}")
    public Result essay(@PathVariable Integer id) {
        // 调用userService的selectUseressay方法，根据用户ID获取个人动态数量
        Integer user = userService.selectUseressay(id);
        // 返回成功结果，包含获取到的用户信息
        return Result.success(user);
    }
    @GetMapping("/concern/{id}")
    public Result concern(@PathVariable Integer id) {
        // 调用userService的selectUserconcern方法，根据用户ID获取关注信息
        Integer user = userService.selectUserconcern(id);
        // 返回成功结果，包含获取到的用户信息
        return Result.success(user);
    }
    @GetMapping("/fans/{id}")
    public Result fans(@PathVariable Integer id) {
        // 调用userService的selectUserOne方法，根据用户ID获取用户信息
        Integer user = userService.selectUserOnefens(id);
        // 返回成功结果，包含获取到的用户信息
        return Result.success(user);
    }
    @GetMapping("/favorites/{id}")
    public Result favorites(@PathVariable Integer id) {
        // 调用userService的selectUserfavorites方法，根据用户ID获取用户收藏
        Integer user = userService.selectUserfavorites(id);
        // 返回成功结果，包含获取到的用户信息
        return Result.success(user);
    }

    @RequestMapping("/findAllId")
    public Result findAllId(Integer id) {
        User user = userService.selectUserOne(id);
        //判断设计师状态
        if(user.getIsDesigner()==0){
            Integer update = userService.update(id);
            if(update==1){
                return Result.success(1);
            }else{
                return Result.error("更新失败");
            }
        }
        return Result.success(user);
    }


    /**
     * 接口：添加动态信息
     */
    @PostMapping("/addArticles")
    public Result addArticles(@RequestBody Articles articles) {
        int i = userService.addArticles(articles);
        if (i > 0){
            return Result.success();
        }else {
            return Result.error("添加失败");
        }
    }

    @GetMapping("/money/{id}")
    public Result money(@PathVariable Integer id) {
        return Result.success(userService.money(id));
    }
    @GetMapping("/transaction/{id}")
    public Result transaction(@PathVariable Integer id) {
        return Result.success(userService.transaction(id));
    }
}
